home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’96 / PredatorPrey / calc_controls.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-22  |  9.9 KB  |  404 lines  |  [TEXT/KAHL]
  1.  
  2.             /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
  3.             /*                                                               */
  4.             /*                    Prototype HP15C Calculator                */
  5.             /*                    James C. Ullrey                            */
  6.             /*                    INRESCO                                    */
  7.             /*                    © 1990                                    */
  8.             /*                    Version    13.97a                            */
  9.             /*                                                               */
  10.             /*                    CONTROL   SEGMENT                           */
  11.             /*                                                               */
  12.             /*                                                            */
  13.             /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
  14.  
  15.  
  16. /*****************************************************************/
  17. /*  I N C L U D E S
  18. /*****************************************************************/
  19.  
  20. #ifndef __C14__
  21. #include    "PredatorPrey.h"
  22. #endif
  23. #include "calc_controls.h"
  24. #include <Controls.h>
  25. #include "calc_update.h"
  26.  
  27.  
  28.  
  29. /********************************************************************
  30. /*  G L O B A L   V A R I A B L E   D E C L A R A T I O N S
  31. /********************************************************************/
  32.  
  33.  
  34.  
  35.  
  36.  
  37. /*****************************************************************/
  38. /*  P R O T O T Y P E S
  39. /*****************************************************************/
  40.  
  41.  
  42.         
  43.  
  44. pascal void do_cntl_button        (ControlHandle cntl_hndl, short part_code);
  45. short         compute_scroll        (ControlHandle cntl_hndl,         
  46.                                  long percent,         
  47.                                  short old_value,         
  48.                                  short direction);
  49.  
  50.  
  51.  
  52. /*****************************************************************/
  53. /*****************************************************************/
  54. /*
  55. /* R O U T I N E S
  56. /*
  57. /*****************************************************************/
  58. /*****************************************************************/
  59.  
  60.  
  61. void    controls_seg(){}    /*  for reference in "UnloadSeg()" calls    */
  62.  
  63.  
  64.  
  65.  
  66.  
  67.  
  68. /*****************************************************************/
  69. /*  D O C O N T R O L S   -   process mousedown in controls
  70. /*****************************************************************/
  71.  
  72. /**
  73.     This routine handles mouse down events in the scrollbars.  For the button
  74.     elements of the scrollbars (up/down arrow & up/down page) the resultant
  75.     activity is handled by the call-back procedure "do_cntl_butn" which in turn
  76.     calls the routine "do_scroll()".  For the thumb the activity is handled 
  77.     directly by the routine "do_scroll()".  It is assumed that if the thumb was 
  78.     not the thumb of the horizontal scrollbar thenm it was the thumb of the 
  79.     vertical scrollbar.  
  80. **/
  81.     
  82.     
  83. void    do_controls(Point local_point,WindowPtr wPtr,ControlHandle cntl_hndl,short control_part)
  84. //Point          local_point;
  85. //WindowPtr      wPtr;
  86. //ControlHandle cntl_hndl;
  87. //short          control_part;
  88.  
  89. {
  90.     ControlActionUPP    myControlProc;
  91.     
  92.     myControlProc = NewControlActionProc((ProcPtr)do_cntl_button);
  93.     
  94.     switch(control_part)
  95.     {
  96.         case inUpButton:                /*    inUpButton        = 20    */
  97.         case inDownButton:                /*    inDownButton    = 21    */
  98.         case inPageUp:                    /*    inPageUp        = 22    */
  99.         case inPageDown:                /*    inPageDown        = 23    */
  100.             //TrackControl(cntl_hndl, local_point, (UniversalProcPtr)do_cntl_button);
  101.             TrackControl(cntl_hndl, local_point, myControlProc);
  102.               break;
  103.                       
  104.         case inThumb:                    /*    inThumb            = 129    */
  105.             if    (
  106.                     #ifdef      powerc
  107.                         TrackControl(cntl_hndl, local_point, (UniversalProcPtr)NIL)
  108.                     #else
  109.                         TrackControl(cntl_hndl, local_point, NIL)
  110.                     #endif      /* powerc */
  111.                 )
  112.             {
  113.                 do_scroll(wPtr,cntl_hndl);
  114.             }
  115.             break;    
  116.     }
  117.  
  118.     return;
  119.  
  120. }  /*  end of do_controls()    */
  121.  
  122.  
  123.  
  124.  
  125.  
  126. /*****************************************************************/
  127. /*  D O  C N T L  B U T T O N   -   Handle mousedowns in scrollbar buttons
  128. /*****************************************************************/
  129.  
  130. /**
  131.     Note that this is a callback procedure referenced in the "TrackControl()"
  132.     calls in "do_controls()", above.  It must be declared as a Pascal routine in
  133.     order to have the calling sequence implemented properly for TrackControl().
  134. **/
  135.     
  136.     
  137. pascal void    do_cntl_button(ControlHandle cntl_hndl,short part_code)
  138. //ControlHandle     cntl_hndl;
  139. //short            part_code;
  140.  
  141. {
  142.     short        old_value, new_value;
  143.     WindowPtr    wPtr;
  144.  
  145.     
  146.  
  147. /*************    Check the control                             **********/
  148.  
  149.  
  150.     if(part_code == NIL) return;
  151.  
  152.  
  153.  
  154. /*************    Adjust new control value as appropriate        **********/
  155.  
  156.  
  157.     old_value = GetCtlValue(cntl_hndl);
  158.     
  159.     switch(part_code)
  160.     {
  161.         case inUpButton:        
  162.             new_value = compute_scroll(cntl_hndl,15, old_value, SCROLL_UP);
  163.               break;
  164.                       
  165.         case inDownButton:
  166.             new_value = compute_scroll(cntl_hndl, 15, old_value, SCROLL_DOWN);
  167.               break;
  168.                       
  169.         case inPageUp:
  170.             new_value = compute_scroll(cntl_hndl, 90, old_value, SCROLL_UP);
  171.               break;
  172.                       
  173.         case inPageDown:
  174.             new_value = compute_scroll(cntl_hndl, 90, old_value, SCROLL_DOWN);
  175.               break;
  176.       }
  177.  
  178.     
  179.  
  180. /*************    Go do the scrolling...                                **********/
  181.  
  182.  
  183.     SetCtlValue(cntl_hndl, new_value);
  184.  
  185.     wPtr = (**cntl_hndl).contrlOwner;
  186.  
  187.     do_scroll(wPtr,cntl_hndl);    /*    this    */
  188.  
  189.     return;
  190.     
  191. }  /*  end of do_cntl_button()    */
  192.  
  193.  
  194.  
  195.  
  196.  
  197. /*****************************************************************/
  198. /*  C O M P U T E S C R O L L    -   based on control values, window, etc
  199. /*****************************************************************/
  200.  
  201. /**
  202.     This routine computes the new value of the scrollbar controls (and thus the
  203.     amount to scroll the window) based on min/max values of the controls and
  204.     the percentage of the window that was specified to scroll.  We are using 
  205.     a control-range that is numerically equal to the document size in pixels, so 
  206.     we can use "control-value-deltas" and "scroll-amounts" interchangeably.
  207. **/
  208.     
  209.     
  210. short    compute_scroll(ControlHandle cntl_hndl,long the_percent,short old_value,short the_direction)
  211. //ControlHandle    cntl_hndl;
  212. //long            the_percent;
  213. //short            old_value, the_direction;
  214.  
  215. {
  216.     short            the_max, the_min, new_value;
  217.     short            h_size, v_size;
  218.     WindowPtr        wPtr;
  219.     WObjsHandle        w_objs_hndl;
  220.     WPObjsHandle    wp_objs_hndl;
  221.     long            amount_to_scroll;
  222.  
  223.     
  224.  
  225. /*************    get the info we need...                                    **********/
  226.  
  227.  
  228.     the_max = GetCtlMax(cntl_hndl);
  229.     the_min = GetCtlMin(cntl_hndl);
  230.     
  231.     wPtr = (**cntl_hndl).contrlOwner;
  232.     if(wPtr == gProgWindow)
  233.     {
  234.         wp_objs_hndl = (WPObjs**)GetWRefCon(wPtr);
  235.         v_size = wPtr->portRect.bottom;
  236.     }
  237.     else
  238.     {
  239.         w_objs_hndl = (WObjs**)GetWRefCon(wPtr);
  240.         v_size = wPtr->portRect.bottom - 15;
  241.     }
  242.     
  243.     h_size = wPtr->portRect.right - 15;        /* we're going to scroll a percentage of */
  244.                                             /* the size of the drawing area of the     */
  245.                                             /* window. (window - scrollbar areas)     */
  246.  
  247.     
  248.  
  249. /*************    Use height or width of window as appropriate            **********/
  250.     
  251.     if(wPtr == gProgWindow)
  252.     {
  253.         amount_to_scroll = ((long)v_size * the_percent) / 100;    /* vertical scroll     */
  254.     }
  255.     else
  256.     {
  257.         if (cntl_hndl == (**w_objs_hndl).myHCntrlHdl)
  258.                 amount_to_scroll = ((long)h_size * the_percent) / 100;    /* horizontal scroll */
  259.         else
  260.                 amount_to_scroll = ((long)v_size * the_percent) / 100;    /* vertical scroll     */
  261.     }
  262.     
  263.  
  264. /*************    Don't go beyond max or min range of scrolling            **********/
  265.  
  266.  
  267.     new_value = (long)old_value + ( (long)the_direction * amount_to_scroll );
  268.     
  269.     if (new_value > the_max) new_value = the_max;
  270.     if (new_value < the_min) new_value = the_min;
  271.  
  272.     return(new_value);
  273.  
  274. }  /*  end of compute_scroll()    */
  275.  
  276.  
  277.  
  278.  
  279.  
  280. /*****************************************************************/
  281. /*  D O  S C R O L L    -   actually does the scrolling
  282. /*****************************************************************/
  283.  
  284. /**
  285.     This routine scrolls the drawing area of the window by the specified amount
  286.     and updates the control values and saved scroll-amount point
  287.     (current total scroll offset) in the window objects record.  Note that the
  288.     area scrolled by "ScrollRect()" is the intersection of the specified rectangle
  289.     and the clip area, visRgn, portRect and portBits.bounds of the window.  Thus
  290.     although we specify a rectangle including the entire drawing area of the window,
  291.     the palette does not get scrolled because it's outside the clip area we defined
  292.     for the window.
  293. **/
  294.     
  295.     
  296. void    do_scroll(WindowPtr wPtr,ControlHandle cntl_hndl)
  297. {
  298.     short            h_scroll, v_scroll;
  299.     short            howMuch;
  300.     Rect            bounds_rect;
  301.     WObjs**            w_objs_hndl;
  302.     WPObjs**        wp_objs_hndl;
  303.     Point            offset;
  304.     ControlHandle    h_cntl_hndl, v_cntl_hndl;
  305.     RgnHandle         my_rgn, saved_clip;
  306.     long            start_ticks, min_delay;
  307.  
  308.         
  309.     
  310. /*********    get current scroll offset amounts (WObjs "scrollAmount")    **********/
  311.  
  312.     if(wPtr == gProgWindow)
  313.     {
  314.         wp_objs_hndl = (WPObjs**)GetWRefCon (wPtr);
  315.         offset = (**wp_objs_hndl).scrollAmount;
  316.         /*v_cntl_hndl = (**wp_objs_hndl).myVCntrlHdl;*/
  317.         h_scroll = 0;
  318.         /*howMuch = GetCtlValue(v_cntl_hndl);*/
  319.         howMuch = GetCtlValue(cntl_hndl);
  320.         v_scroll = offset.v - howMuch;
  321.         LScroll( 0, v_scroll, progList );
  322.         /*LDoDraw(TRUE,progList);*/
  323.     }
  324.     else
  325.     {
  326.         w_objs_hndl = (WObjs**)GetWRefCon (wPtr);
  327.         offset = (**w_objs_hndl).scrollAmount;
  328.         h_cntl_hndl = (**w_objs_hndl).myHCntrlHdl;
  329.         v_cntl_hndl = (**w_objs_hndl).myVCntrlHdl;
  330.         h_scroll = offset.h - GetCtlValue(h_cntl_hndl);
  331.         v_scroll = offset.v - GetCtlValue(v_cntl_hndl);
  332.     }
  333.     
  334.  
  335.     if((h_scroll == 0) && (v_scroll == 0)) return;
  336.  
  337.     start_ticks = TickCount();
  338.     min_delay = 12;
  339.     
  340.  
  341.  
  342. /*************    Set up the area to be scrolled (window - scrollbars)    **********/
  343.  
  344.  
  345.     SetRect(&bounds_rect,wPtr->portRect.left,
  346.                          wPtr->portRect.top,
  347.                          wPtr->portRect.right  - 15,
  348.                          wPtr->portRect.bottom - 15);
  349.  
  350.     
  351.  
  352. /*************    Save the current state of the machine                    **********/
  353.  
  354.  
  355.     SetPort(wPtr);
  356.     
  357.     saved_clip = NewRgn();
  358.     GetClip(saved_clip);
  359.  
  360.     
  361.  
  362. /*********    Set clip area to exclude palette and go do the scrolling    **********/
  363.  
  364.  
  365.         clip_4_palette(wPtr);
  366.  
  367.         my_rgn = NewRgn();
  368.         ScrollRect(&bounds_rect, h_scroll, v_scroll, my_rgn);
  369.         InvalRgn(my_rgn);
  370.  
  371.  
  372.      SetClip(saved_clip);
  373.  
  374.     DisposeRgn(my_rgn);
  375.     DisposeRgn(saved_clip);
  376.  
  377.     
  378.  
  379. /*************    Update the scroll offset value in WObjs record        **********/
  380.  
  381.  
  382.     offset.h -= h_scroll;
  383.     offset.v -= v_scroll;
  384.     
  385.     if(wPtr == gProgWindow)
  386.     {
  387.         (**wp_objs_hndl).scrollAmount = offset;
  388.     }
  389.     else
  390.     {
  391.         (**w_objs_hndl).scrollAmount = offset;
  392.     }
  393.     
  394.  
  395. /*********    Process the update immediately                             **********/
  396.  
  397.     
  398.      do_update(wPtr);
  399.          
  400.     while (TickCount() < start_ticks + min_delay) {};
  401.     
  402.  
  403. }  /*  end of do_scroll()    */
  404.